<?php
namespace yifang\model\relation;

use yifang\model\Relation;
use Closure;
use yifang\utils\Str;
use yifang\db\BaseQuery as Query;
use yifang\model\Model;
use yifang\model\Pivot;
use yifang\db\Raw;
use Exception;

/**
 * 多态关联类
 */
class MorphTo extends Relation
{
    /**
     * 多态关联外键
     * @var string
     */
    protected $morphKey;

    /**
     * 多态字段
     * @var string
     */
    protected $morphType;

    /**
     * 多态别名
     * @var array
     */
    protected $alias = [];

    /**
     * 关联名
     * @var string
     */
    protected $relation;

    protected $queryCaller = [];

    /**
     * 架构函数
     */
    public function __construct(Model $parent,  $morphType,  $morphKey, array $alias = [],  $relation = null)
    {
        $this->parent    = $parent;
        $this->morphType = $morphType;
        $this->morphKey  = $morphKey;
        $this->alias     = $alias;
        $this->relation  = $relation;
    }

    /**
     * 获取当前的关联模型类的实例
     * @access public
     * @return Model
     */
    public function getModel()
    {
        $morphType = $this->morphType;
        $model     = $this->parseModel($this->parent->$morphType);
        return (new $model);
    }

    /**
     * 延迟获取关联数据
     * @return Model
     */
    public function getRelation(array $subRelation = [], Closure $closure = null)
    {
        $morphKey  = $this->morphKey;
        $morphType = $this->morphType;
        // 多态模型
        $model = $this->parseModel($this->parent->$morphType);
        // 主键数据
        $pk = $this->parent->$morphKey;
        $relationModel = $this->buildQuery((new $model)->relation($subRelation))->find($pk);
        if ($relationModel) {
            $relationModel->setParent(clone $this->parent);
        }
        return $relationModel;
    }

    /**
     * 根据关联条件查询当前模型
     * @return Query
     */
    public function has($operator = '>=', $count = 1,  $id = '*',  $joinType = '', Query $query = null)
    {
        return $this->parent;
    }

    /**
     * 根据关联条件查询当前模型
     * @return Query
     */
    public function hasWhere($where = [], $fields = null,  $joinType = '', Query $query = null)
    {
        $alias = class_basename($this->parent);
        $types = $this->parent->distinct()->column($this->morphType);
        $query = $query ?: $this->parent->db();
        return $query->alias($alias)
            ->where(function (Query $query) use ($types, $where, $alias) {
                foreach ($types as $type) {
                    if ($type) {
                        $query->whereExists(function (Query $query) use ($type, $where, $alias) {
                            $class = $this->parseModel($type);
                            /** @var Model $model */
                            $model = new $class();

                            $table = $model->getTable();
                            $query
                                ->table($table)
                                ->where($alias . '.' . $this->morphType, $type)
                                ->whereRaw("`{$alias}`.`{$this->morphKey}`=`{$table}`.`{$model->getPk()}`")
                                ->where($where);
                        }, 'OR');
                    }
                }
            });
    }

    /**
     * 解析模型的完整命名空间
     * @return Model
     */
    protected function parseModel($model)
    {
        if (isset($this->alias[$model])) {
            $model = $this->alias[$model];
        }
        if (false === strpos($model, '\\')) {
            $path = explode('\\', get_class($this->parent));
            array_pop($path);
            array_push($path, Str::studly($model));
            $model = implode('\\', $path);
        }
        return $model;
    }

    /**
     * 设置多态别名
     * @return $this
     */
    public function setAlias(array $alias)
    {
        $this->alias = $alias;
        return $this;
    }

    /**
     * 移除关联查询参数
     * @access public
     * @return $this
     */
    public function removeOption($option = '')
    {
        return $this;
    }

    /**
     * 预载入关联查询
     * @return void
     * @throws Exception
     */
    public function eagerlyResultSet(array &$resultSet,  $relation, array $subRelation, Closure $closure = null, array $cache = [])
    {
        $morphKey  = $this->morphKey;
        $morphType = $this->morphType;
        $range     = [];
        foreach ($resultSet as $result) {
            // 获取关联外键列表
            if (!empty($result->$morphKey)) {
                $range[$result->$morphType][] = $result->$morphKey;
            }
        }
        if (!empty($range)) {
            foreach ($range as $key => $val) {
                // 多态类型映射
                $model = $this->parseModel($key);
                $obj   = new $model;
                if (!\is_null($closure)) {
                    $obj = $closure($obj);
                }
                $pk   = $obj->getPk();
                $list = $obj->with($subRelation)
                    ->cache($cache[0] ?? false, $cache[1] ?? null, $cache[2] ?? null)
                    ->select($val);
                $data = [];
                foreach ($list as $k => $vo) {
                    $data[$vo->$pk] = $vo;
                }
                foreach ($resultSet as $result) {
                    if ($key == $result->$morphType) {
                        // 关联模型
                        if (!isset($data[$result->$morphKey])) {
                            $relationModel = null;
                        } else {
                            $relationModel = $data[$result->$morphKey];
                            $relationModel->setParent(clone $result);
                            $relationModel->exists(true);
                        }
                        $result->setRelation($relation, $relationModel);
                    }
                }
            }
        }
    }

    /**
     * 预载入关联查询
     * @return void
     */
    public function eagerlyResult(Model $result,  $relation, array $subRelation = [], Closure $closure = null, array $cache = [])
    {
        // 多态类型映射
        $model = $this->parseModel($result->{$this->morphType});
        $this->eagerlyMorphToOne($model, $relation, $result, $subRelation, $cache);
    }

    /**
     * 关联统计
     * @return integer
     */
    public function relationCount(Model $result, Closure $closure = null,  $aggregate = 'count',  $field = '*')
    {
    }

    /**
     * 多态MorphTo 关联模型预查询
     * @return void
     */
    protected function eagerlyMorphToOne($model,  $relation, Model $result, array $subRelation = [], array $cache = [])
    {
        // 预载入关联查询 支持嵌套预载入
        $pk = $this->parent->{$this->morphKey};
        $data = null;
        if (\class_exists($model)) {
            $data = (new $model)->with($subRelation)
                ->cache($cache[0] ?? false, $cache[1] ?? null, $cache[2] ?? null)
                ->find($pk);
            if ($data) {
                $data->setParent(clone $result);
                $data->exists(true);
            }
        }
        $result->setRelation($relation, $data ?: null);
    }

    /**
     * 添加关联数据
     * @return Model
     */
    public function associate(Model $model,  $type = '')
    {
        $morphKey  = $this->morphKey;
        $morphType = $this->morphType;
        $pk        = $model->getPk();
        $this->parent->setAttr($morphKey, $model->$pk);
        $this->parent->setAttr($morphType, $type ?: get_class($model));
        $this->parent->save();
        return $this->parent->setRelation($this->relation, $model);
    }

    /**
     * 注销关联数据
     * @access public
     * @return Model
     */
    public function dissociate()
    {
        $morphKey  = $this->morphKey;
        $morphType = $this->morphType;
        $this->parent->setAttr($morphKey, null);
        $this->parent->setAttr($morphType, null);
        $this->parent->save();
        return $this->parent->setRelation($this->relation, null);
    }

    protected function buildQuery(Query $query)
    {
        foreach ($this->queryCaller as $caller) {
            call_user_func_array([$query, $caller[0]], $caller[1]);
        }
        return $query;
    }

    public function __call($method, $args)
    {
        $this->queryCaller[] = [$method, $args];
        return $this;
    }
}
